{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Content under Creative Commons Attribution license CC-BY 4.0, code under BSD 3-Clause License © 2017 L.A. Barba, N.C. Clementi, modified by D. Koehn © 2019"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<link href=\"https://fonts.googleapis.com/css?family=Merriweather:300,300i,400,400i,700,700i,900,900i\" rel='stylesheet' >\n",
       "<link href=\"https://fonts.googleapis.com/css?family=Source+Sans+Pro:300,300i,400,400i,700,700i\" rel='stylesheet' >\n",
       "<link href='http://fonts.googleapis.com/css?family=Source+Code+Pro:300,400' rel='stylesheet' >\n",
       "<style>\n",
       "\n",
       "@font-face {\n",
       "    font-family: \"Computer Modern\";\n",
       "    src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n",
       "}\n",
       "\n",
       "\n",
       "#notebook_panel { /* main background */\n",
       "    background: rgb(245,245,245);\n",
       "}\n",
       "\n",
       "div.cell { /* set cell width */\n",
       "    width: 800px;\n",
       "}\n",
       "\n",
       "div #notebook { /* centre the content */\n",
       "    background: #fff; /* white background for content */\n",
       "    width: 1000px;\n",
       "    margin: auto;\n",
       "    padding-left: 0em;\n",
       "}\n",
       "\n",
       "#notebook li { /* More space between bullet points */\n",
       "margin-top:0.5em;\n",
       "}\n",
       "\n",
       "/* draw border around running cells */\n",
       "div.cell.border-box-sizing.code_cell.running { \n",
       "    border: 1px solid #111;\n",
       "}\n",
       "\n",
       "/* Put a solid color box around each cell and its output, visually linking them*/\n",
       "div.cell.code_cell {\n",
       "    background-color: rgb(256,256,256); \n",
       "    border-radius: 0px; \n",
       "    padding: 0.5em;\n",
       "    margin-left:1em;\n",
       "    margin-top: 1em;\n",
       "}\n",
       "\n",
       "\n",
       "div.text_cell_render{\n",
       "    font-family: 'Source Sans Pro', sans-serif;\n",
       "    line-height: 140%;\n",
       "    font-size: 110%;\n",
       "    width:680px;\n",
       "    margin-left:auto;\n",
       "    margin-right:auto;\n",
       "}\n",
       "\n",
       "/* Formatting for header cells */\n",
       ".text_cell_render h1 {\n",
       "    font-family: 'Merriweather', serif;\n",
       "    font-style:regular;\n",
       "    font-weight: bold;    \n",
       "    font-size: 250%;\n",
       "    line-height: 100%;\n",
       "    color: #004065;\n",
       "    margin-bottom: 1em;\n",
       "    margin-top: 0.5em;\n",
       "    display: block;\n",
       "}\t\n",
       ".text_cell_render h2 {\n",
       "    font-family: 'Merriweather', serif;\n",
       "    font-weight: bold; \n",
       "    font-size: 180%;\n",
       "    line-height: 100%;\n",
       "    color: #0096d6;\n",
       "    margin-bottom: 0.5em;\n",
       "    margin-top: 0.5em;\n",
       "    display: block;\n",
       "}\t\n",
       "\n",
       ".text_cell_render h3 {\n",
       "    font-family: 'Merriweather', serif;\n",
       "\tfont-size: 150%;\n",
       "    margin-top:12px;\n",
       "    margin-bottom: 3px;\n",
       "    font-style: regular;\n",
       "    color: #008367;\n",
       "}\n",
       "\n",
       ".text_cell_render h4 {    /*Use this for captions*/\n",
       "    font-family: 'Merriweather', serif;\n",
       "    font-weight: 300; \n",
       "    font-size: 100%;\n",
       "    line-height: 120%;\n",
       "    text-align: left;\n",
       "    width:500px;\n",
       "    margin-top: 1em;\n",
       "    margin-bottom: 2em;\n",
       "    margin-left: 80pt;\n",
       "    font-style: regular;\n",
       "}\n",
       "\n",
       ".text_cell_render h5 {  /*Use this for small titles*/\n",
       "    font-family: 'Source Sans Pro', sans-serif;\n",
       "    font-weight: regular;\n",
       "    font-size: 130%;\n",
       "    color: #e31937;\n",
       "    font-style: italic;\n",
       "    margin-bottom: .5em;\n",
       "    margin-top: 1em;\n",
       "    display: block;\n",
       "}\n",
       "\n",
       ".text_cell_render h6 { /*use this for copyright note*/\n",
       "    font-family: 'Source Code Pro', sans-serif;\n",
       "    font-weight: 300;\n",
       "    font-size: 9pt;\n",
       "    line-height: 100%;\n",
       "    color: grey;\n",
       "    margin-bottom: 1px;\n",
       "    margin-top: 1px;\n",
       "}\n",
       "\n",
       "    .CodeMirror{\n",
       "            font-family: \"Source Code Pro\";\n",
       "\t\t\tfont-size: 90%;\n",
       "    }\n",
       "/*    .prompt{\n",
       "        display: None;\n",
       "    }*/\n",
       "\t\n",
       "    \n",
       "    .warning{\n",
       "        color: rgb( 240, 20, 20 )\n",
       "        }  \n",
       "</style>\n",
       "<script>\n",
       "    MathJax.Hub.Config({\n",
       "                        TeX: {\n",
       "                           extensions: [\"AMSmath.js\"], \n",
       "                           equationNumbers: { autoNumber: \"AMS\", useLabelIds: true}\n",
       "                           },\n",
       "                tex2jax: {\n",
       "                    inlineMath: [ ['$','$'], [\"\\\\(\",\"\\\\)\"] ],\n",
       "                    displayMath: [ ['$$','$$'], [\"\\\\[\",\"\\\\]\"] ]\n",
       "                },\n",
       "                displayAlign: 'center', // Change this to 'center' to center equations.\n",
       "                \"HTML-CSS\": {\n",
       "                    styles: {'.MathJax_Display': {\"margin\": 4}}\n",
       "                }\n",
       "        });\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Execute this cell to load the notebook's style sheet, then ignore it\n",
    "from IPython.core.display import HTML\n",
    "css_file = '../style/custom.css'\n",
    "HTML(open(css_file, \"r\").read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Short Jupyter and Python tutorial\n",
    "\n",
    "This is the second lesson of our course in _\"Engineering Computations.\"_ In the first lesson, [_Interacting with Python_](http://nbviewer.jupyter.org/github/engineersCode/EngComp/blob/8693986dbc0554495930c87bae7283bfa78130bd/modules/1_offtheground/1_Interacting_with_Python.ipynb), we used **IPython**, the interactive Python shell. It is really great to type single-line Python expressions and get the outputs, interactively. Yet, believe it or not, there are greater things! \n",
    "\n",
    "In this lesson, you will continue playing with data using Python, but you will do so in a **Jupyter notebook**. This very lesson is written in a Jupyter notebook. Ready? You will love it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is Jupyter?\n",
    "\n",
    "Jupyter is a set of open-source tools for interactive and exploratory computing. You work right on your browser, which becomes the user interface through which Jupyter gives you a file explorer (the _dashboard_) and a document format: the **notebook**.\n",
    "\n",
    "A Jupyter notebook can contain: input and output of code, formatted text, images, videos, pretty math equations, and much more. The computer code is _executable_, which means that you can run the bits of code, right in the document, and get the output of that code displayed for you. This interactive way of computing, mixed with the multi-media narrative, allows you to tell a story (even to yourself) with extra powers!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Working in Jupyter\n",
    "\n",
    "Several things will seem counter-intuitive to you at first. For example, most people are used to launching apps in their computers by clicking some icon: this is the first thing to \"unlearn.\" Jupyter is launched from the _command line_ (like when you launched IPython). Next, we have two types of content—code and markdown—that handle a bit differently. The fact that your browser is an interface to a compute engine (called \"kernel\") leads to some extra housekeeping (like shutting down the kernel). But you'll get used to it pretty quick!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Start Jupyter\n",
    "\n",
    "The standard way to start Jupyter is to type the following in the command-line interface:\n",
    "\n",
    "`jupyter notebook` \n",
    "\n",
    "Hit enter and tadah!!\n",
    "After a little set up time, your default browser will open with the Jupyter app. It should look like in the screenshot below, but you may see a list of files and folders, depending on the location of your computer where you launched it.\n",
    "\n",
    "##### Note:\n",
    "\n",
    "Don't close the terminal window where you launched Jupyter (while you're still working on Jupyter). If you need to do other tasks on the command line, open a new terminal window.\n",
    "\n",
    "<img src=\"images/jupyter-main.png\" style=\"width: 800px;\"/> \n",
    "#### Screenshot of the Jupyter dashboard, open in the browser.\n",
    "\n",
    "\n",
    "To start a new Jupyter notebook, click on the top-right, where it says **New**, and select `Python 3`. Check out the screenshot below.\n",
    "\n",
    "<img src=\"images/create_notebook.png\" style=\"width: 800px;\"/> \n",
    "#### Screenshot showing how to create a new notebook.\n",
    "\n",
    "A new tab will appear in your browser and you will see an empty notebook, with a single input line, waiting for you to enter some code. See the next screenshot.\n",
    "\n",
    "<img src=\"images/new_notebook.png\" style=\"width: 800px;\"/> \n",
    "#### Screenshot showing an empty new notebook.\n",
    "\n",
    "The notebook opens by default with a single empty code cell. Try to write some Python code there and execute it by hitting `[shift] + [enter]`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Notebook cells\n",
    "\n",
    "The Jupyter notebook uses _cells_: blocks that divide chunks of text and code. Any text content is entered in a *Markdown* cell: it contains text that you can format using simple markers to get headings, bold, italic, bullet points, hyperlinks, and more.\n",
    "\n",
    "Markdown is easy to learn, check out the syntax in the [\"Daring Fireball\"](https://daringfireball.net/projects/markdown/syntax) webpage (by John Gruber). A few tips:\n",
    "\n",
    "* to create a title, use a hash to start the line: `# Title`\n",
    "* to create the next heading, use two hashes (and so on): `## Heading`\n",
    "* to italicize a word or phrase, enclose it in asterisks (or underdashes): `*italic*` or `_italic_`\n",
    "* to make it bold, enclose it with two asterisks: `**bolded**`\n",
    "* to make a hyperlink, use square and round brackets: `[hyperlinked text](url)`\n",
    "\n",
    "Computable content is entered in code cells. We will be using the IPython kernel (\"kernel\" is the name used for the computing engine), but you should know that Jupyter can be used with many different computing languages. It's amazing.\n",
    "\n",
    "A code cell will show you an input mark, like this: \n",
    "\n",
    "`In [ ]:`\n",
    "\n",
    "Once you add some code and execute it, Jupyter will add a number ID to the input cell, and produce an output marked like this:\n",
    "\n",
    "`Out [1]:`\n",
    "\n",
    "##### A bit of history: \n",
    "\n",
    "Markdown was co-created by the legendary but tragic [Aaron Swartz](https://en.wikipedia.org/wiki/Aaron_Swartz). The biographical documentary about him is called [\"The Internet's Own Boy,\"](https://en.wikipedia.org/wiki/The_Internet%27s_Own_Boy) and you can view it in YouTube or Netflix. Recommended!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Other stuff you can incorporate into your notebook\n",
    "\n",
    "Beside plain text, hyperlinks and code it is also possible to incorporate LaTeX code, images and YouTube movies in notebook cells.\n",
    "\n",
    "To type equations, you can also use LaTeX, for example the acoustic wave equation is\n",
    "\n",
    "$\\frac{1}{v_p^2}\\frac{\\partial^2 P}{\\partial t^2} = \\nabla^2 P$\n",
    "\n",
    "with the pressure $P$, P-wave velocity $v_p$, time $t$ and the Laplace operator $\\nabla^2$\n",
    "\n",
    "Images can be incorporated in a notebook cell by\n",
    "\n",
    "`<img src=\"images/image_name\" style=\"width: 800px;\"/>`\n",
    "\n",
    "Let's take a look into the future of the TEW2 lecture:\n",
    "\n",
    "<img src=\"images/TEW2_overview.jpg\" style=\"width: 800px;\"/>\n",
    "\n",
    "You can also embed YouTube videos in your Jupyter notebook, like this time-lapse movie of a starry night:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "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\n",
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"400\"\n",
       "            height=\"300\"\n",
       "            src=\"https://www.youtube.com/embed/1vHWlRio8n0\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.YouTubeVideo at 0x1a4bc093cc0>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "YouTubeVideo('1vHWlRio8n0')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also call external programs like Matlab or compiled Fortran and C code. Essentially, you could easily write your whole Master thesis in a Jupyter notebook and ensure that your work is documented and also reproducible."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interactive computing in the notebook\n",
    "\n",
    "Look at the icons on the menu of Jupyter (see the screenshots above). The first icon on the left (an old floppy disk) is for saving your notebook. You can add a new cell with the big **+** button. Then you have the cut, copy, and paste buttons. The arrows are to move your current cell up or down. Then you have a button to \"run\" a code cell (execute the code), the square icon means \"stop\" and the swirly arrow is to \"restart\" your notebook's kernel (if the computation is stuck, for example). Next to that, you have the cell-type selector: Code or Markdown (or others that you can ignore for now).\n",
    "\n",
    "You can test-drive a code cell by writing some arithmetic operations, for example the Python operators which are:\n",
    "```python\n",
    "    +   -   *   /   **   %   //\n",
    "```\n",
    "\n",
    "There's addition, subtraction, multiplication and division. The last three operators are _exponent_ (raise to the power of), _modulo_ (divide and return remainder) and _floor division_.\n",
    "\n",
    "Typing `[shift] + [enter]` will execute the cell and give you the output in a new line, labeled `Out[1]` (the numbering increases each time you execute a cell).\n",
    "\n",
    "##### Try it!\n",
    "\n",
    "Add a cell with the plus button, enter some operations, and `[shift] + [enter]` to execute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try out some of the things, like \"Hello World!\" or basic calculations: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Edit mode and Command mode\n",
    "\n",
    "Once you click on a notebook cell to select it, you may interact with it in two ways, which are called _modes_. Later on, when you are reviewing this material again, read more about this in Reference 1. \n",
    "\n",
    "**Edit mode:**\n",
    "\n",
    "* We enter **edit mode** by pressing `Enter` or double-clicking on the cell.\n",
    "\n",
    "* We know we are in this mode when we see a green cell border and a prompt in the cell area.\n",
    "\n",
    "* When we are in edit mode, we can type into the cell, like a normal text editor.\n",
    "\n",
    "\n",
    "**Command mode:**\n",
    "\n",
    "* We enter in **command mode** by pressing `Esc` or clicking outside the cell area.\n",
    "\n",
    "* We know we are in this mode when we see a grey cell border with a left blue margin.\n",
    "\n",
    "* In this mode, certain keys are mapped to shortcuts to help with\n",
    "  common actions.\n",
    "\n",
    "\n",
    "You can find a list of the shortcuts by selecting `Help->Keyboard Shortcuts`\n",
    "from the notebook menu bar. You may want to leave this for later, and come back to it, but it becomes more helpful the more you use Jupyter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How to shut down the kernel and exit\n",
    "\n",
    "Closing the browser tab where you've been working on a notebook does not immediately \"shut down\" the compute kernel. So you sometimes need to do a little housekeeping.\n",
    "\n",
    "Once you close a notebook, you will see in the main Jupyter app that your \n",
    "notebook file has a green book symbol next to it. You should click in the box at the left of that symbol, and then click where it says **Shutdown**. You don't need to do this all the time, but if you have a _lot_ of notebooks running, they will use resources in your machine.\n",
    "\n",
    "Similarly, Jupyter is still running even after you close the tab that has the Jupyter dashboard open. To exit the Jupyter app, you should go to the terminal that you used to open Jupyter, and type `[Ctrl] + [c]` to exit."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nbviewer\n",
    "\n",
    "[Nbviewer](http://nbviewer.jupyter.org/) is a free web service that allows you to share static versions of hosted notebook files, as if they were a web page. If a notebook file is publicly available on the web, you can view it by entering its URL in the nbviewer web page, and hitting the **Go!** button. The notebook will be rendered as a static page: visitors can read everything, but they cannot interact with the code. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is Python?\n",
    "\n",
    "Python is now 26 years old. Its creator, [Guido van Rossum](https://en.wikipedia.org/wiki/Guido_van_Rossum), named it after the British comedy \"Monty Python's Flying Circus.\" His goals for the language were that it be an \"an easy and intuitive language just as powerful as major competitors,\" producing computer code \"that is as understandable as plain English.\"\n",
    "\n",
    "It is a general-purpose language, which means that you can use it for anything:  organizing data, scraping the web, creating websites, analyzing sounds, creating games, and of course _engineering computations_.\n",
    "\n",
    "Python is an interpreted language. This means that you can write Python commands and the computer can execute those instructions directly. Other programming languages—like C, C++ and Fortran—require a previous _compilation_ step: translating the commands into machine language.\n",
    "A neat ability of Python is to be used _interactively_. [Fernando Perez](https://en.wikipedia.org/wiki/Fernando_Pérez_(software_developer)) famously created **IPython** as a side-project during his PhD."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Why Python?\n",
    "\n",
    "\n",
    "_Because it's fun!_ With Python, the more you learn, the more you _want_ to learn.\n",
    "You can find lots of resources online and, since Python is an open-source project, you'll also find a friendly community of people sharing their knowledge. \n",
    "\n",
    "Python is known as a _high-productivity language_. As a programmer, you'll need less time to develop a solution with Python than with most languages. \n",
    "This is important to always bring up whenever someone complains that \"Python is slow.\"\n",
    "Your time is more valuable than a machine's!\n",
    "(See the Recommended Readings section at the end.)\n",
    "And if we really need to speed up our program, we can re-write the slow parts in a compiled language afterwards.\n",
    "Because Python plays well with other languages :–)\n",
    "\n",
    "The top technology companies use Python: Google, Facebook, Dropbox, Wikipedia, Yahoo!, YouTube… And this year, Python took the No. 1 spot in the interactive list of [The 2017 Top Programming Languages](http://spectrum.ieee.org/computing/software/the-2017-top-programming-languages), by _IEEE Spectrum_ ([IEEE](http://www.ieee.org/about/index.html) is the world's largest technical professional society). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### _Python is a versatile language, you can analyze data, build websites (e.g., Instagram, Mozilla, Pinterest), make art or music, etc. Because it is a versatile language, employers love Python: if you know Python they will want to hire you._ —Jessica McKellar, ex Director of the Python Software Foundation, in a [2014 tutorial](https://youtu.be/rkx5_MRAV3A)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Your first program\n",
    "\n",
    "In every programming class ever, your first program consists of printing a _\"Hello\"_ message. In Python, you use the `print()` function, with your message inside quotation marks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world!!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello world!!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Easy peasy!! You just wrote your first program and you learned how to use the `print()` function. Yes, `print()` is a function: we pass the _argument_ we want the function to act on, inside the parentheses. In the case above, we passed a _string_, which is a series of characters between quotation marks. Don't worry, we will come back to what strings are later on in this lesson.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Key concept: function\n",
    "\n",
    "A function is a compact collection of code that executes some action on its _arguments_.  Every Python function has a _name_, used to call it, and takes its arguments inside round brackets. Some arguments may be optional (which means they have a default value defined inside the function), others are required. For example, the `print()` function has one required argument: the string of characters it should print out for you.\n",
    "\n",
    "Python comes with many _built-in_ functions, but you can also build your own. Chunking blocks of code into functions is one of the best strategies to deal with complex programs. It makes you more efficient, because you can reuse the code that you wrote into a function. Modularity and reuse are every programmer's friend."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python as a calculator\n",
    "\n",
    "Try any arithmetic operation in IPython. The symbols are what you would expect, except for the \"raise-to-the-power-of\" operator, which you obtain with two asterisks: `**`. Try all of these:\n",
    "\n",
    "```python\n",
    "+   -   *   /   **   %   //\n",
    "```\n",
    "\n",
    "The `%` symbol is the _modulo_ operator (divide and return remainder), and the double-slash is _floor division_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.9"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1.25 + 3.65"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 - 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 * 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.5"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see an interesting case:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.5"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "9**1/2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_What happened?_ Isn't $9^{1/2} = 3$? (Raising to the power $1/2$ is the same as taking the square root.) Did Python get this wrong?\n",
    "\n",
    "Compare with this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "9**(1/2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yes! The order of operations matters! \n",
    "\n",
    "If you don't remember what we are talking about, review the [Arithmetics/Order of operations](https://en.wikibooks.org/wiki/Arithmetic/Order_of_Operations). A frequent situation that exposes this is the following:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables and their type\n",
    "\n",
    "Variables consist of two parts: a name and a value. When we want to give a variable its name and value, we use the equal sign: `name = value`. This is called an _assignment_. The name of the variable goes on the left and the value on the right. \n",
    "\n",
    "The first thing to get used to is that the equal sign in an assignment has a different meaning than it has in Algebra! Think of it as an arrow pointing from `name` to `value`.\n",
    "\n",
    "\n",
    "<img src=\"images/variables.png\" style=\"width: 400px;\"/> \n",
    "\n",
    "We have many possibilities for variable names: they can be made up of upper and lowercase letters, underscores and digits… although digits cannot go on the front of the name. For example, valid variable names are:\n",
    "\n",
    "```python\n",
    "    x\n",
    "    x1\n",
    "    X_2\n",
    "    name_3\n",
    "    NameLastname\n",
    "```\n",
    "Keep in mind, there are reserved words that you can't use; they are the special Python [keywords](https://docs.python.org/3/reference/lexical_analysis.html#keywords).\n",
    "  \n",
    "OK. Let's assign some values to variables and do some operations with them: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = 4.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's do some arithmetic operations with our new variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.5"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y - 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String variables\n",
    "\n",
    "In addition to name and value, Python variables have a _type_: the type of the value it refers to. For example, an integer value has type `int`, and a real number has type `float`. A string is a variable consisting of a sequence of characters marked by two quotes, and it has type `str`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = 'this is a string'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "w = '1'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " What if you try to \"add\" two strings?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'this is a string1'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z + w"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The operation above is called _concatenation_: chaining two strings together into one. Insteresting, eh? But look at this:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-22-7414e72702f9>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mx\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mw\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "x + w"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Error!_ Why? Let's inspect what Python has to say and explore what is happening. \n",
    "\n",
    "Python is a _dynamic language_, which means that you don't _need_ to specify a type to invoke an existing object. The humorous nickname for this is \"duck typing\":\n",
    "\n",
    "#### \"If it looks like a duck, and quacks like a duck, then it's probably a duck.\"\n",
    "\n",
    "In other words, a variable has a type, but we don't need to specify it. It will just behave like it's supposed to when we operate with it (it'll quack and walk like nature intended it to).\n",
    "\n",
    "But sometimes you need to make sure you know the type of a variable. Thankfully, Python offers a function to find out the type of a variable: `type()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### More assignments\n",
    "\n",
    "What if you want to assign to a new variable the result of an operation that involves other variables? Well, you totally can!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum_xy = x + y\n",
    "diff_xy = x - y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of x and y is: 7.5\n",
      "The difference between x and y is: -1.5\n"
     ]
    }
   ],
   "source": [
    "print('The sum of x and y is:', sum_xy)\n",
    "print('The difference between x and y is:', diff_xy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice what we did above: we used the `print()` function with a string message, followed by a variable, and Python printed a useful combination of the message and the variable value. This is a pro tip! You want to print for humans. Let's now check the type of the new variables we just created above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(sum_xy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(diff_xy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Some more advanced computations\n",
    "\n",
    "In order to compute more advanced functions, we have to import the `NumPy` library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, let 's try some functions, like sine and cosine"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numpy.cos(0.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numpy.sin(0.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice, that the underlying `NumPy` functions use angles in radians instead of degrees as input parameters. However, if you prefer degrees, `NumPy` can also solve this problem  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numpy.sin(numpy.deg2rad(90))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What about complex numbers? With the imaginary number\n",
    "\n",
    "$j^2 = -1$ you can define complex numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = 1 + 2j"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "complex"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also add and multiply complex number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = 2 + 1j"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3+3j)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y + z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5j"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y * z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Real and imaginary parts can be extracted by the `NumPy` functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(2.0)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numpy.real(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(1.0)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numpy.imag(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vectors\n",
    "\n",
    "We can define vectors in many different ways, e.g. as a `NumPy` array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6 7]\n"
     ]
    }
   ],
   "source": [
    "a = numpy.array([1, 2, 3, 4, 5, 6, 7])\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matlab users should be cautioned, because the index of the first vector element is not 1 but 0, so you access the first element by"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The last element is accessible by the index -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What element is accessed by the index -2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As in Matlab you can also access different ranges of vector elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[0:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compared to Matlab, the last element is **not** inclusive. \n",
    "Computation with vectors is quite easy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 6  7  8  9 10 11 12]\n"
     ]
    }
   ],
   "source": [
    "b = a + 5\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Due to the equal length of vectors a and b, we can simply add them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 7  9 11 13 15 17 19]\n"
     ]
    }
   ],
   "source": [
    "c = a + b\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or apply elementwise multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 6 14 24 36 50 66 84]\n"
     ]
    }
   ],
   "source": [
    "d = a * b\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can transpose the vector "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = c.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and calculate the scalar product of two vectors by vector-vector multiplication `@`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "420"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a @ c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vectors with equidistant elements can be created by:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "f = numpy.arange(0,10)\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the last element is **not** inclusive! Another significant difference compared to Matlab, so keep this in mind, when creating vectors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10]\n"
     ]
    }
   ],
   "source": [
    "f = numpy.arange(0,11)\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10 12 14 16 18 20]\n"
     ]
    }
   ],
   "source": [
    "g = numpy.arange(10,21,2)\n",
    "print(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can replace individual elements in a vector or delete them. Do not forget that the first vector element has index 0 and the last element is not inclusive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  0   1   2   3 100   5   6   7   8   9  10]\n"
     ]
    }
   ],
   "source": [
    "# set f[4] = 100\n",
    "f[4] = 100\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  1   1   1   3 100   5   6   7   8   9  10]\n"
     ]
    }
   ],
   "source": [
    "# set f[0], f[1], f[2] = 1\n",
    "f[0:3] = 1\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  1  1 10]\n"
     ]
    }
   ],
   "source": [
    "# delete elements 3 - 9\n",
    "f = numpy.delete(f,numpy.arange(3,10))\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can concatenate vectors to new vectors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "[1 2 3 1 2 3 1 2 3]\n"
     ]
    }
   ],
   "source": [
    "k = numpy.arange(1,4)\n",
    "print(k)\n",
    "l = numpy.hstack((k, k, k))\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or new matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [1 2 3]\n",
      " [1 2 3]]\n"
     ]
    }
   ],
   "source": [
    "M = numpy.vstack((k, k, k))\n",
    "print(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrices\n",
    "\n",
    "Similar to vectors we can access matrix elements. Again, I emphasize that the first index is 0 and the last element is not inclusive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 3],\n",
       "       [2, 3]])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1:3,1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar to Matlab you can access matrix rows via `:`, the second row of matrix M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[1,:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Special matrix operations are for example the diagonal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numpy.diag(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or the inverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [5 7 6]\n",
      " [1 4 6]]\n"
     ]
    }
   ],
   "source": [
    "A = numpy.matrix('1 2 3; 5 7 6; 1 4 6')\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[  2.00000000e+00,  -3.33066907e-17,  -1.00000000e+00],\n",
       "        [ -2.66666667e+00,   3.33333333e-01,   1.00000000e+00],\n",
       "        [  1.44444444e+00,  -2.22222222e-01,  -3.33333333e-01]])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.I"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[  1.00000000e+00,   0.00000000e+00,   1.11022302e-16],\n",
       "        [ -2.22044605e-15,   1.00000000e+00,  -6.66133815e-16],\n",
       "        [ -4.44089210e-16,   0.00000000e+00,   1.00000000e+00]])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A @ A.I"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### For-loops and if-statements\n",
    "\n",
    "Two important aspects of flow control in a Python code are `For`-loops and `If`-statements. Again, I emphasize that the last element in the loop is not inclusive:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i =  1\n",
      "i =  2\n",
      "i =  3\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,4):\n",
    "    print(\"i = \", i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "h=0\n",
    "for i in range(1,4):\n",
    "    h = h + i\n",
    "print(h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before discussing `If`-statements, we introduce the logical operators `<=`, `==`, `>=`, `or`, `and` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1\n",
    "b = 2\n",
    "c = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a <= 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a >= 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b == 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a <= 2 and b==2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a <=2 or a>=2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we can control the flow inside the `FOR`-loop with `if`-statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i =  2\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,4):\n",
    "    if(i>=2 and i<3):\n",
    "        print(\"i = \", i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions\n",
    "\n",
    "It is good coding practice to *avoid repeating* ourselves: we want to write code that is reusable, not only because it leads to less typing but also because it reduces errors. If you find yourself doing the same calculation multiple times, it's better to encapsulate it into a *function*. \n",
    "\n",
    "A function is a compact collection of code that executes some action on its arguments. \n",
    "\n",
    "Once *defined*, you can *call* a function as many times as you want. When we *call* a function, we execute all the code inside the function. The result of the execution depends on the *definition* of the function and on the values that are *passed* into it as *arguments*. Functions might or might not *return* values in their last operation.   \n",
    "\n",
    "The syntax for defining custom Python functions is:\n",
    "\n",
    "```python\n",
    "def function_name(arg_1, arg_2, ...):\n",
    "    '''\n",
    "    docstring: description of the function\n",
    "    '''\n",
    "    <body of the function>\n",
    "```\n",
    "\n",
    "The **docstring** of a function is a message from the programmer documenting what he or she built. Docstrings should be descriptive and concise. They are important because they explain (or remind) the intended use of the function to the users. You can later access the docstring of a function using the function `help()` and passing the name of the function. If you are in a notebook, you can also prepend a question mark `'?'` before the name of the function and run the cell to display the information of a function. \n",
    "\n",
    "Let 's try it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "?numpy.sin"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Time to write our own `Python` function. Do you now the date of easter sunday this year? That's quite important, because on the following monday there will be no TEW2 lecture. ;-)\n",
    "\n",
    "Let's write a Python function to calculate the date using the \n",
    "\n",
    "[Easter algorithm by Carl Friedrich Gauss](https://en.wikipedia.org/wiki/Computus#Gauss's_Easter_algorithm):\n",
    "\n",
    "a = year mod 19\n",
    "\n",
    "b = year mod 4\n",
    "\n",
    "c = year mod 7\n",
    "\n",
    "k = floor(year/100)\n",
    "\n",
    "p = floor((13 + 8k)/25)\n",
    "\n",
    "q = floor(k/4)\n",
    "\n",
    "M = (15 - p + k - q) mod 30\n",
    "\n",
    "N = (4 + k - q) mod 7\n",
    "\n",
    "d = (19a + M) mod 30\n",
    "\n",
    "e = (2b + 4c + 6d + N) mod 7\n",
    "\n",
    "Gregorian Easter is 22 + d + e March or d + e − 9 April\n",
    "\n",
    "if d = 29 and e = 6, replace 26 April with 19 April\n",
    "\n",
    "if d = 28, e = 6, and (11M + 11) mod 30 < 19, replace 25 April with 18 April\n",
    "\n",
    "With a modified version you can also calculate the [jewish Passover date](https://opacplus.bsb-muenchen.de/Vta2/bsb10538597/bsb:7519973?page=447)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gauss_easter(year):\n",
    "    \n",
    "    '''\n",
    "    Computation of easter date using the Computus by Carl Friedrich Gauss\n",
    "    input parameter: year\n",
    "    '''\n",
    "    \n",
    "    a = year % 19\n",
    "    b = year % 4\n",
    "    c = year % 7\n",
    "    \n",
    "    k = year//100\n",
    "    p = (13 + 8 * k) // 25\n",
    "    q = k // 4\n",
    "    \n",
    "    M = (15 - p + k - q) % 30\n",
    "    N = (4 + k - q) % 7\n",
    "    \n",
    "    d = (19 * a + M) % 30\n",
    "    e = (2 * b + 4 * c + 6 * d + N) % 7\n",
    "    \n",
    "    if(22 + d + e <= 31):\n",
    "        print(\"Gregorian Easter is\", 22 + d + e, \"of March\")\n",
    "        \n",
    "    if(d + e - 9 > 0.0):\n",
    "        \n",
    "        if(d==29 and e==6):            \n",
    "            print(\"Gregorian Easter is\", 19, \"of April\") \n",
    "            \n",
    "        elif(d==28 and e ==6 and ((11 * M + 11) % 30) < 19):\n",
    "            print(\"Gregorian Easter is\", 18, \"of April\")\n",
    "            \n",
    "        else:\n",
    "            print(\"Gregorian Easter is\", d + e - 9, \"of April\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gregorian Easter is 30 of March\n"
     ]
    }
   ],
   "source": [
    "# calculate easter for year 1777\n",
    "gauss_easter(1777)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gregorian Easter is 21 of April\n"
     ]
    }
   ],
   "source": [
    "# calculate easter for year 2019\n",
    "gauss_easter(2019)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gregorian Easter is 18 of April\n"
     ]
    }
   ],
   "source": [
    "# calculate easter for year 2049\n",
    "gauss_easter(2049)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gregorian Easter is 19 of April\n"
     ]
    }
   ],
   "source": [
    "# calculate easter for year 1981\n",
    "gauss_easter(1981)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Time to Plot\n",
    "\n",
    "You will love the Python library **Matplotlib**! You'll learn here about its module `pyplot`, which makes line plots. \n",
    "\n",
    "We need some data to plot. Let's define a NumPy array, compute derived data using its square, cube and square root (element-wise), and plot these values with the original array in the x-axis. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.    0.05  0.1   0.15  0.2   0.25  0.3   0.35  0.4   0.45  0.5   0.55\n",
      "  0.6   0.65  0.7   0.75  0.8   0.85  0.9   0.95  1.    1.05  1.1   1.15\n",
      "  1.2   1.25  1.3   1.35  1.4   1.45  1.5   1.55  1.6   1.65  1.7   1.75\n",
      "  1.8   1.85  1.9   1.95  2.  ]\n"
     ]
    }
   ],
   "source": [
    "xarray = numpy.linspace(0, 2, 41)\n",
    "print(xarray)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "pow2 = xarray**2\n",
    "pow3 = xarray**3\n",
    "pow_half = numpy.sqrt(xarray)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To plot the resulting arrays as a function of the orginal one (`xarray`) in the x-axis, we need to import the module `pyplot` from **Matplotlib**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll use the `pyplot.plot()` function, specifying the line color (`'k'` for black) and line style (`'-'`, `'--'` and `':'` for continuous, dashed and dotted line), and giving each line a label. Note that the values for `color`, `linestyle` and `label` are given in quotes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1a4be2359b0>"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Plot x^2\n",
    "pyplot.plot(xarray, pow2, color='k', linestyle='-', label='square')\n",
    "#Plot x^3\n",
    "pyplot.plot(xarray, pow3, color='k', linestyle='--', label='cube')\n",
    "#Plot sqrt(x)\n",
    "pyplot.plot(xarray, pow_half, color='k', linestyle=':', label='square root')\n",
    "#Plot the legends in the best location\n",
    "pyplot.legend(loc='best')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To illustrate other features, we will plot the same data, but varying the colors instead of the line style. We'll also use LaTeX syntax to write formulas in the labels. If you want to know more about LaTeX syntax, there is a [quick guide to LaTeX](https://users.dickinson.edu/~richesod/latex/latexcheatsheet.pdf) available online.\n",
    "\n",
    "Adding a semicolon (`';'`) to the last line in the plotting code block prevents that ugly output, like `<matplotlib.legend.Legend at 0x7f8c83cc7898>`. Try it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Plot x^2\n",
    "pyplot.plot(xarray, pow2, color='red', linestyle='-', label='$x^2$')\n",
    "#Plot x^3\n",
    "pyplot.plot(xarray, pow3, color='green', linestyle='-', label='$x^3$')\n",
    "#Plot sqrt(x)\n",
    "pyplot.plot(xarray, pow_half, color='blue', linestyle='-', label='$\\sqrt{x}$')\n",
    "#Plot the legends in the best location\n",
    "pyplot.legend(loc='best'); "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's very nice! By now, you are probably imagining all the great stuff you can do with Jupyter notebooks, Python and its scientific libraries **NumPy** and **Matplotlib**. We just saw an introduction to plotting but we will keep learning about the power of **Matplotlib** in the next lesson. \n",
    "\n",
    "If you are curious, you can explore all the beautiful plots you can make by browsing the [Matplotlib gallery](http://matplotlib.org/gallery.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What we've learned\n",
    "\n",
    "* How to use the Jupyter environnment.\n",
    "* Using the `print()` function. The concept of _function_.\n",
    "* Using Python as a calculator.\n",
    "* Concepts of variable, type, assignment.\n",
    "* Some more advanced compuations.\n",
    "* How to define vectors/matrices and apply basic operations to them.\n",
    "* Calculation of easter sunday for a given year using a Python function.\n",
    "* Basic plotting with `pyplot`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References\n",
    "\n",
    "1. [Notebook Basics: Modal Editor](http://jupyter-notebook.readthedocs.io/en/latest/examples/Notebook/Notebook%20Basics.html)\n",
    "2. [\"Indices point between elements,\"](https://blog.nelhage.com/2015/08/indices-point-between-elements/) blog post by Nelson Elhage (2015).\n",
    "3. _Python for Everybody: Exploring Data Using Python 3_ (2016). Charles R. Severance. [PDF available](http://do1.dr-chuck.com/pythonlearn/EN_us/pythonlearn.pdf)\n",
    "4. _Think Python: How to Think Like a Computer Scientist_ (2012). Allen Downey. Green Tea Press.  [PDF available](http://greenteapress.com/thinkpython/thinkpython.pdf)\n",
    "5. _Effective Computation in Physics: Field Guide to Research with Python_ (2015). Anthony Scopatz & Kathryn D. Huff. O'Reilly Media, Inc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Recommended Readings\n",
    "\n",
    "- [\"Yes, Python is Slow, and I Don’t Care\"](https://hackernoon.com/yes-python-is-slow-and-i-dont-care-13763980b5a1) by Nick Humrich, on Hackernoon. (Skip the part on microservices, which is a bit specialized, and continue after the photo of moving car lights.)\n",
    "- [\"Why I Push for Python\"](http://lorenabarba.com/blog/why-i-push-for-python/), by Prof. Lorena A. Barba (2014). This blog post got a bit of interest over at [Hacker News](https://news.ycombinator.com/item?id=7760870)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  },
  "widgets": {
   "state": {},
   "version": "1.1.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
